home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLSRC.PAK / DISPATCH.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  14.6 KB  |  599 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1992, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.10  $
  6. //
  7. // Implementation of OWL message dispatcher functions
  8. //----------------------------------------------------------------------------
  9. #include <owl/pch.h>
  10. #if !defined(OWL_DISPATCH_H)
  11. # include <owl/dispatch.h>
  12. #endif
  13.  
  14. OWL_DIAGINFO;
  15.  
  16. //----------------------------------------------------------------------------
  17.  
  18. #if defined(BI_NAMESPACE)
  19. namespace OWL {
  20. #endif
  21.   
  22. int32 _OWLFUNC
  23. i_LPARAM_Dispatch(GENERIC& generic,
  24.                   int     (GENERIC::*pmf)(int32),
  25.                   uint,
  26.                   int32    param2)
  27. {
  28.   return (generic.*pmf)(param2);
  29. }
  30.  
  31. int32 _OWLFUNC
  32. i_WPARAM_Dispatch(GENERIC& generic,
  33.                   int     (GENERIC::*pmf)(uint),
  34.                   uint     param1,
  35.                   int32)
  36. {
  37.   return (generic.*pmf)(param1);
  38. }
  39.  
  40. int32 _OWLFUNC
  41. B_WPARAM_Dispatch(GENERIC& generic,
  42.                   bool     (GENERIC::*pmf)(uint),
  43.                   uint     param1,
  44.                   int32)
  45. {
  46.   return (generic.*pmf)(param1);
  47. }
  48.  
  49. int32 _OWLFUNC
  50. B_B_Dispatch(GENERIC& generic,
  51.              bool     (GENERIC::*pmf)(bool),
  52.              uint     param1,
  53.              int32)
  54. {
  55.   return (generic.*pmf)((bool)param1);
  56. }
  57.  
  58. //----------------------------------------------------------------------------
  59.  
  60. int32 _OWLFUNC
  61. I32_Dispatch(GENERIC& generic,
  62.              uint32  (GENERIC::*pmf)(),
  63.              uint,
  64.              int32)
  65. {
  66.   return (generic.*pmf)();
  67. }
  68.  
  69. int32 _OWLFUNC
  70. I32_LPARAM_Dispatch(GENERIC& generic,
  71.                     int32  (GENERIC::*pmf)(int32),
  72.                     uint,
  73.                     int32    param2)
  74. {
  75.   return (generic.*pmf)(param2);
  76. }
  77.  
  78. //
  79. // Passes param2 as a uint and returns an int32 result
  80. //
  81. int32 _OWLFUNC
  82. I32_U_Dispatch(GENERIC& generic,
  83.                int32   (GENERIC::*pmf)(uint),
  84.                uint,
  85.                int32    param2)
  86. {
  87.   return (generic.*pmf)((uint)param2);
  88. }
  89.  
  90. //
  91. // Passes param2 as an int and returns bool
  92. //
  93. int32 _OWLFUNC
  94. B_I2_Dispatch(GENERIC& generic,
  95.                bool  (GENERIC::*pmf)(int),
  96.                uint,
  97.                int32    param2)
  98. {
  99.   return (generic.*pmf)((int)param2);
  100. }
  101.  
  102. int32 _OWLFUNC
  103. I32_WPARAM_LPARAM_Dispatch(GENERIC& generic,
  104.                            int32   (GENERIC::*pmf)(uint, int32),
  105.                            uint     param1,
  106.                            int32    param2)
  107. {
  108.   return (generic.*pmf)(param1, param2);
  109. }
  110.  
  111. //----------------------------------------------------------------------------
  112.  
  113. int32 _OWLFUNC
  114. U_Dispatch(GENERIC& generic,
  115.            uint  (GENERIC::*pmf)(),
  116.            uint,
  117.            int32)
  118. {
  119.   return (generic.*pmf)();
  120. }
  121.  
  122. int32 _OWLFUNC
  123. U32_Dispatch(GENERIC& generic,
  124.              uint32  (GENERIC::*pmf)(),
  125.              uint,
  126.              int32)
  127. {
  128.   return (generic.*pmf)();
  129. }
  130.  
  131. int32 _OWLFUNC
  132. B_Dispatch(GENERIC& generic,
  133.            bool(GENERIC::*pmf)(),
  134.            uint,
  135.            int32)
  136. {
  137.   return (generic.*pmf)();
  138. }
  139.  
  140. int32 _OWLFUNC
  141. B_LPARAM_Dispatch(GENERIC& generic,
  142.                   bool    (GENERIC::*pmf)(int32),
  143.                   uint,
  144.                   int32    param2)
  145. {
  146.   return (generic.*pmf)(param2) != false;
  147. }
  148.  
  149. int32 _OWLFUNC
  150. U_LPARAM_Dispatch(GENERIC& generic,
  151.                   uint    (GENERIC::*pmf)(int32),
  152.                   uint,
  153.                   int32    param2)
  154. {
  155.   return (generic.*pmf)(param2);
  156. }
  157.  
  158. int32 _OWLFUNC
  159. U_POINT_Dispatch(GENERIC& generic,
  160.                  uint    (GENERIC::*pmf)(TPoint&),
  161.                  uint,
  162.                  int32    param2)
  163. {
  164. #if defined(BI_PLAT_WIN32)
  165.   return (generic.*pmf)(TPoint(param2));
  166. #else
  167.   return (generic.*pmf)(*(TPoint*)¶m2);  // 16-bit cast trick
  168. #endif
  169. }
  170.  
  171. int32 _OWLFUNC
  172. U_POINTER_Dispatch(GENERIC& generic,
  173.                    uint    (GENERIC::*pmf)(void*),
  174.                    uint,
  175.                    int32    param2)
  176. {
  177.   return (generic.*pmf)((void*)param2);
  178. }
  179.  
  180. int32 _OWLFUNC
  181. B_POINTER_Dispatch(GENERIC& generic,
  182.                    bool    (GENERIC::*pmf)(void*),
  183.                    uint,
  184.                    int32    param2)
  185. {
  186.   return (generic.*pmf)((void*)param2);
  187. }
  188.  
  189. int32 _OWLFUNC
  190. U_U_Dispatch(GENERIC& generic,
  191.              uint    (GENERIC::*pmf)(uint),
  192.              uint     param1,
  193.              int32)
  194. {
  195.   return (generic.*pmf)((uint)param1);
  196. }
  197.  
  198. int32 _OWLFUNC
  199. U_B_Dispatch(GENERIC& generic,
  200.              uint    (GENERIC::*pmf)(bool),
  201.              uint     param1,
  202.              int32)
  203. {
  204.   return (generic.*pmf)((bool)param1);
  205. }
  206.  
  207. int32 _OWLFUNC
  208. B_B_U_Dispatch(GENERIC& generic,
  209.              bool    (GENERIC::*pmf)(bool, uint),
  210.              uint     param1,
  211.              int32    param2)
  212. {
  213.   return (generic.*pmf)((bool)param1, (uint)param2);
  214. }
  215.  
  216. int32 _OWLFUNC
  217. U_U_RECT_Dispatch(GENERIC& generic,
  218.                   uint    (GENERIC::*pmf)(uint, TRect&),
  219.                   uint     param1,
  220.                   int32    param2)
  221. {
  222. #if defined(BI_DATA_NEAR)
  223.   TRect rect(*(RECT far*)param2);
  224.   uint i = (generic.*pmf)(param1, rect);
  225.   *(RECT far*)param2 = rect;
  226.   return i;
  227. #else
  228.   return (generic.*pmf)(param1, *(TRect*)param2);
  229. #endif
  230. }
  231.  
  232. int32 _OWLFUNC
  233. B_U_RECT_Dispatch(GENERIC& generic,
  234.                   bool    (GENERIC::*pmf)(uint, TRect&),
  235.                   uint     param1,
  236.                   int32    param2)
  237. {
  238. #if defined(BI_DATA_NEAR)
  239.   TRect rect(*(RECT far*)param2);
  240.   bool b = (generic.*pmf)(param1, rect);
  241.   *(RECT far*)param2 = rect;
  242.   return b;
  243. #else
  244.   return (generic.*pmf)(param1, *(TRect*)param2);
  245. #endif
  246. }
  247.  
  248. int32 _OWLFUNC
  249. U_U_U_U_Dispatch(GENERIC& generic,
  250.                  uint    (GENERIC::*pmf)(uint, uint, uint),
  251.                  uint     param1,
  252.                  int32    param2)
  253. {
  254.   return (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  255. }
  256.  
  257. int32 _OWLFUNC
  258. U_U_U_Dispatch(GENERIC& generic,
  259.                uint    (GENERIC::*pmf)(uint, uint),
  260.                uint     wParam,
  261.                int32    lParam)
  262. {
  263.   return (generic.*pmf)(wParam, uint(lParam));
  264. }
  265.  
  266. int32 _OWLFUNC
  267. U_B_U_Dispatch(GENERIC& generic,
  268.                uint    (GENERIC::*pmf)(bool, uint),
  269.                uint     wParam,
  270.                int32    lParam)
  271. {
  272.   return (generic.*pmf)((bool)wParam, uint(lParam));
  273. }
  274.  
  275. int32 _OWLFUNC
  276. B_U_U_Dispatch(GENERIC& generic,
  277.                bool    (GENERIC::*pmf)(uint, uint),
  278.                uint     wParam,
  279.                int32    lParam)
  280. {
  281.   return (generic.*pmf)(wParam, (uint)lParam); //cast for 16-bit compatability
  282. }
  283.  
  284. int32 _OWLFUNC
  285. B_U_U_U_Dispatch(GENERIC& generic,
  286.                  bool    (GENERIC::*pmf)(uint, uint, uint),
  287.                  uint     param1,
  288.                  int32    param2)
  289. {
  290.   return (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  291. }
  292.  
  293. int32 _OWLFUNC
  294. U_WPARAM_LPARAM_Dispatch(GENERIC& generic,
  295.                          uint    (GENERIC::*pmf)(uint, int32),
  296.                          uint     param1,
  297.                          int32    param2)
  298. {
  299.   return (generic.*pmf)(param1, param2);
  300. }
  301.  
  302. int32 _OWLFUNC
  303. B_WPARAM_LPARAM_Dispatch(GENERIC& generic,
  304.                          bool    (GENERIC::*pmf)(uint, int32),
  305.                          uint     param1,
  306.                          int32    param2)
  307. {
  308.   return (generic.*pmf)(param1, param2);
  309. }
  310.  
  311. int32 _OWLFUNC
  312. U_B_LPARAM_Dispatch(GENERIC& generic,
  313.                     uint    (GENERIC::*pmf)(bool, int32),
  314.                     uint     param1,
  315.                     int32    param2)
  316. {
  317.   return (generic.*pmf)((bool)param1, param2);
  318. }
  319.  
  320. //----------------------------------------------------------------------------
  321.  
  322. int32 _OWLFUNC
  323. v_Dispatch(GENERIC& generic,
  324.            void    (GENERIC::*pmf)(),
  325.            uint,
  326.            int32)
  327. {
  328.   (generic.*pmf)();
  329.   return 0;
  330. }
  331.  
  332. int32 _OWLFUNC
  333. v_LPARAM_Dispatch(GENERIC& generic,
  334.                   void    (GENERIC::*pmf)(int32),
  335.                   uint,
  336.                   int32    param2)
  337. {
  338.   (generic.*pmf)(param2);
  339.   return 0;
  340. }
  341.  
  342. int32 _OWLFUNC
  343. v_POINT_Dispatch(GENERIC& generic,
  344.                  void    (GENERIC::*pmf)(TPoint&),
  345.                  uint,
  346.                  int32    param2)
  347. {
  348. #if defined(BI_PLAT_WIN32)
  349.   (generic.*pmf)(TPoint(param2));
  350. #else
  351.   (generic.*pmf)(*(TPoint*)¶m2);  // 16-bit cast trick
  352. #endif
  353.   return 0;
  354. }
  355.  
  356. int32 _OWLFUNC
  357. v_POINTER_Dispatch(GENERIC& generic,
  358.                    void    (GENERIC::*pmf)(void*),
  359.                    uint,
  360.                    int32    param2)
  361. {
  362.   (generic.*pmf)((void*)param2);
  363.   return 0;
  364. }
  365.  
  366. int32 _OWLFUNC
  367. v_U_Dispatch(GENERIC& generic,
  368.              void    (GENERIC::*pmf)(uint),
  369.              uint,
  370.              int32    param2)
  371. {
  372.   (generic.*pmf)((uint)param2);
  373.   return 0;
  374. }
  375.  
  376. int32 _OWLFUNC
  377. v_U_POINT_Dispatch(GENERIC& generic,
  378.                    void    (GENERIC::*pmf)(uint, TPoint&),
  379.                    uint     param1,
  380.                    int32    param2)
  381. {
  382. #if defined(BI_PLAT_WIN32)
  383.   (generic.*pmf)(param1, TPoint(param2));
  384. #else
  385.   (generic.*pmf)(param1, *(TPoint*)¶m2);  // 16-bit cast trick
  386. #endif
  387.   return 0;
  388. }
  389.  
  390. int32 _OWLFUNC
  391. v_U_U_Dispatch(GENERIC& generic,
  392.                void    (GENERIC::*pmf)(uint, uint),
  393.                uint     param1,
  394.                int32    param2)
  395. {
  396.   (generic.*pmf)(param1, (uint)param2);
  397.   return 0;
  398. }
  399.  
  400. int32 _OWLFUNC
  401. v_U_B_Dispatch(GENERIC& generic,
  402.                void    (GENERIC::*pmf)(uint, bool),
  403.                uint     param1,
  404.                int32    param2)
  405. {
  406.   (generic.*pmf)(param1, (bool)param2);
  407.   return 0;
  408. }
  409.  
  410. int32 _OWLFUNC
  411. v_B_U_Dispatch(GENERIC& generic,
  412.                void    (GENERIC::*pmf)(bool, uint),
  413.                uint     param1,
  414.                int32    param2)
  415. {
  416.   (generic.*pmf)((bool)param1, (uint)param2);
  417.   return 0;
  418. }
  419.  
  420. int32 _OWLFUNC
  421. v_U_U_U_Dispatch(GENERIC& generic,
  422.                  void    (GENERIC::*pmf)(uint, uint, uint),
  423.                  uint     param1,
  424.                  int32    param2)
  425. {
  426.   (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  427.   return 0;
  428. }
  429.  
  430. int32 _OWLFUNC
  431. v_B_U_U_Dispatch(GENERIC& generic,
  432.                  void    (GENERIC::*pmf)(bool, uint, uint),
  433.                  uint     param1,
  434.                  int32    param2)
  435. {
  436.   (generic.*pmf)((bool)param1, LoUint16(param2), HiUint16(param2));
  437.   return 0;
  438. }
  439.  
  440. int32 _OWLFUNC
  441. v_U_U_B_Dispatch(GENERIC& generic,
  442.                  void    (GENERIC::*pmf)(uint, uint, bool),
  443.                  uint     param1,
  444.                  int32    param2)
  445. {
  446.   (generic.*pmf)(param1, LoUint16(param2), (bool)HiUint16(param2));
  447.   return 0;
  448. }
  449.  
  450. int32 _OWLFUNC
  451. v_WPARAM_Dispatch(GENERIC& generic,
  452.                   void    (GENERIC::*pmf)(uint),
  453.                   uint     param1,
  454.                   int32)
  455. {
  456.   (generic.*pmf)(param1);
  457.   return 0;
  458. }
  459.  
  460. int32 _OWLFUNC
  461. v_B_Dispatch(GENERIC& generic,
  462.                   void    (GENERIC::*pmf)(bool),
  463.                   uint     param1,
  464.                   int32)
  465. {
  466.   (generic.*pmf)((bool)param1);
  467.   return 0;
  468. }
  469.  
  470. int32 _OWLFUNC
  471. v_B_B_Dispatch(GENERIC& generic,
  472.                   void    (GENERIC::*pmf)(bool, bool),
  473.                   uint     param1,
  474.                   int32    param2)
  475. {
  476.   (generic.*pmf)((bool)param1, (bool)param2);
  477.   return 0;
  478. }
  479.  
  480. #if defined(BI_PLAT_WIN32)
  481. int32 _OWLFUNC
  482. v_HWND_PCOPYDATASTRUCT_Dispatch(GENERIC& generic,
  483.                          void    (GENERIC::*pmf)(HWND, COPYDATASTRUCT*),
  484.                          uint     param1,
  485.                          int32    param2)
  486. {
  487.   (generic.*pmf)((HWND)param1, (COPYDATASTRUCT*)param2);
  488.   return true;
  489. }
  490. #endif
  491.  
  492. int32 _OWLFUNC
  493. v_WPARAM_LPARAM_Dispatch(GENERIC& generic,
  494.                          void    (GENERIC::*pmf)(uint, int32),
  495.                          uint     param1,
  496.                          int32    param2)
  497. {
  498.   (generic.*pmf)(param1, param2);
  499.   return 0;
  500. }
  501.  
  502. //----------------------------------------------------------------------------
  503. //
  504. // Semi-custom message crackers
  505. //
  506. int32 _OWLFUNC
  507. i_U_W_U_Dispatch(GENERIC& generic,
  508.                  int     (GENERIC::*pmf)(uint, uint, uint),
  509.                  uint     param1,
  510.                  int32    param2)
  511. {
  512. #if defined(BI_PLAT_WIN32)
  513.   return (generic.*pmf)(LoUint16(param1), param2, HiUint16(param1));
  514. #else
  515.   return (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  516. #endif
  517. }
  518.  
  519. int32 _OWLFUNC
  520. v_U_U_W_Dispatch(GENERIC& generic,
  521.                  void    (GENERIC::*pmf)(uint, uint, uint),
  522.                  uint     param1,
  523.                  int32    param2)
  524. {
  525. #if defined(BI_PLAT_WIN32)
  526.   (generic.*pmf)(LoUint16(param1), HiUint16(param1), param2);
  527. #else
  528.   (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  529. #endif
  530.   return 0;
  531. }
  532.  
  533. //----------------------------------------------------------------------------
  534. //
  535. // Custom message crackers
  536. //
  537.  
  538. int32 _OWLFUNC
  539. v_Activate_Dispatch(GENERIC& generic,
  540.                     void    (GENERIC::*pmf)(uint, bool, uint),
  541.                     uint     param1,
  542.                     int32    param2)
  543. {
  544. #if defined(BI_PLAT_WIN32)
  545.   (generic.*pmf)(LoUint16(param1), (bool)HiUint16(param1), param2);
  546. #else
  547.   (generic.*pmf)(param1, (bool)HiUint16(param2), LoUint16(param2));
  548. #endif
  549.   return 0;
  550. }
  551.  
  552. int32 _OWLFUNC
  553. v_MdiActivate_Dispatch(GENERIC& generic,
  554.                        void    (GENERIC::*pmf)(uint, uint),
  555.                        uint     param1,
  556.                        int32    param2)
  557. {
  558. #if defined(BI_PLAT_WIN32)
  559.   (generic.*pmf)(param2, param1);
  560. #else
  561.   (generic.*pmf)(LoUint16(param2), param2 ? HiUint16(param2) : param1);
  562. #endif
  563.   return 0;
  564. }
  565.  
  566. int32 _OWLFUNC
  567. I32_MenuChar_Dispatch(GENERIC& generic,
  568.                       int32   (GENERIC::*pmf)(uint, uint, uint),
  569.                       uint     param1,
  570.                       int32    param2)
  571. {
  572. #if defined(BI_PLAT_WIN32)
  573.   return (generic.*pmf)(LoUint16(param1), HiUint16(param1), param2);
  574. #else
  575.   return (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  576. #endif
  577. }
  578.  
  579. int32 _OWLFUNC
  580. v_ParentNotify_Dispatch(GENERIC& generic,
  581.                         void    (GENERIC::*pmf)(uint, uint, uint),
  582.                         uint     param1,
  583.                         int32    param2)
  584. {
  585. #if defined(BI_PLAT_WIN32)
  586.   if (LoUint16(param1) >= WM_MOUSEFIRST && LoUint16(param1) <= WM_MOUSELAST)
  587.     (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  588.   else
  589.     (generic.*pmf)(LoUint16(param1), param2, HiUint16(param1));
  590. #else
  591.   (generic.*pmf)(param1, LoUint16(param2), HiUint16(param2));
  592. #endif
  593.   return 0;
  594. }
  595.  
  596. #if defined(BI_NAMESPACE)
  597. } // namespace OWL
  598. #endif
  599.